home *** CD-ROM | disk | FTP | other *** search
/ Java 1996 August / Java - Summer 1996.iso / kaffe-0.2 / kaffe / support.c < prev    next >
C/C++ Source or Header  |  1996-02-12  |  4KB  |  193 lines
  1. /*
  2.  * support.c
  3.  * Native language support.
  4.  *
  5.  * Copyright (c) 1996 Systems Architecture Research Centre,
  6.  *           City University, London, UK.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  12.  */
  13.  
  14. #include <assert.h>
  15. #include <stdarg.h>
  16. #include "constants.h"
  17. #include "baseClasses.h"
  18. #include "classMethod.h"
  19. #include "lookup.h"
  20. #include "errors.h"
  21. #include "md.h"
  22.  
  23. #define    MAXEXCEPTIONLEN        200
  24. #define    CONSTRUCTOR_NAME    "<init>"
  25. #define    ERROR_SIGNATURE        "(Ljava/lang/String;)V"
  26.  
  27. void classname2pathname(char*, char*);
  28.  
  29. /*
  30.  * Convert an Java String to a C string.
  31.  */
  32. char*
  33. javaString2CString(stringClass* js, char* cs, int len)
  34. {
  35.     if (len > js->count) {
  36.         len = js->count;
  37.     }
  38.     strncpy(cs, STRING_OBJ2DATA(js->value), len);
  39.     cs[len] = 0;    /* Is this necessary ? */
  40.     return (cs);
  41. }
  42.  
  43. /*
  44.  * Convert a C string into a Java String.
  45.  */
  46. stringClass*
  47. makeJavaString(char* cs, int len)
  48. {
  49.     return (getString(STRING_DATA2BASE(addString(cs))));
  50. }
  51.  
  52. /*
  53.  * Call a Java method from native code.
  54.  */
  55. long
  56. do_execute_java_method(void* ee, object* obj, char* method_name, char* signature, methods* mb, bool isStaticCall, ...)
  57. {
  58.     void* func;
  59.     char* sig;
  60.     int args;
  61.     va_list ap;
  62.  
  63.     if (mb != 0 && mb->ncode != 0) {
  64.         func = mb->ncode;
  65.     }
  66.     else {
  67.         func = findMethod(obj->type, addStringPair(method_name, signature));
  68.         if (func == 0) {
  69.             throwException(NoSuchMethodError);
  70.         }
  71.     }
  72.  
  73.     /* Calculate number of arguments */
  74.     sig = signature;
  75.     args = sizeofSig(&sig);
  76.  
  77.     /* Make the call */
  78.     va_start(ap, isStaticCall);
  79.      CALL_KAFFE_FUNCTION_VARARGS(func, obj, args, ap);
  80.     va_end(ap);
  81.  
  82.     return (0);
  83. }
  84.  
  85. /*
  86.  * Call a Java static method on a class from native code.
  87.  */
  88. long
  89. do_execute_java_class_method(char* cname, char* method_name, char* signature, ...)
  90. {
  91.     void* func;
  92.     char* sig;
  93.     int args;
  94.     va_list ap;
  95.     classes* class;
  96.  
  97.     /* Convert "." to "/" */
  98.     classname2pathname(cname, cname);
  99.  
  100.     class = lookupClass(addString(cname));
  101.     assert(class != 0);
  102.     func = findMethod(class, addStringPair(method_name, signature));
  103.     if (func == 0) {
  104.         throwException(NoSuchMethodError);
  105.     }
  106.  
  107.     /* Calculate number of arguments */
  108.     sig = signature;
  109.     args = sizeofSig(&sig);
  110.  
  111.     /* Make the call */
  112.     va_start(ap, signature);
  113.      CALL_KAFFE_FUNCTION_VARARGS(func, 0, args, ap);
  114.     va_end(ap);
  115.  
  116.     return (0);
  117. }
  118.  
  119. /*
  120.  * Allocate and object and execute the constructor.
  121.  */
  122. object*
  123. execute_java_constructor(void* ee, char* cname, classes* cc, char* signature, ...)
  124. {
  125.     int args;
  126.     object* obj;
  127.     void* func;
  128.     char* sig;
  129.     va_list ap;
  130.     char buf[MAXEXCEPTIONLEN];
  131.     int i;
  132.  
  133.     if (cc == 0) {
  134.         /* Convert "." to "/" */
  135.         classname2pathname(cname, buf);
  136.  
  137.         cc = lookupClass(addString(buf));
  138.         assert(cc != 0);
  139.     }
  140.  
  141.     func = findMethod(cc, addStringPair(CONSTRUCTOR_NAME, signature));
  142.     if (func == 0) {
  143.         throwException(NoSuchMethodError);
  144.     }
  145.  
  146.     obj = alloc_object(cc, false);
  147.     assert(obj != 0);
  148.  
  149.     /* Calculate number of arguments */
  150.     sig = signature;
  151.     args = sizeofSig(&sig);
  152.  
  153.     /* Make the call */
  154.     va_start(ap, signature);
  155.      CALL_KAFFE_FUNCTION_VARARGS(func, obj, args, ap);
  156.     va_end(ap);
  157.  
  158.     return (obj);
  159. }
  160.  
  161.  
  162. /*
  163.  * Signal an error by creating the object and throwing the exception.
  164.  */
  165. void
  166. SignalError(void* ee, char* cname, char* str)
  167. {
  168.     object* obj;
  169.  
  170.     obj = execute_java_constructor(ee, cname, 0, ERROR_SIGNATURE, makeJavaString(str, strlen(str)));
  171.     throwException(obj);
  172. }
  173.  
  174. /*
  175.  * Convert a class name to a path name.
  176.  */
  177. void
  178. classname2pathname(char* from, char* to)
  179. {
  180.     int i;
  181.  
  182.     /* Convert any '.' in name to '/' */
  183.     for (i = 0; from[i] != 0; i++) {
  184.         if (from[i] == '.') {
  185.             to[i] = '/';
  186.         }
  187.         else {
  188.             to[i] = from[i];
  189.         }
  190.     }
  191.     to[i] = 0;
  192. }
  193.